'use server'

import db from '@/db/db'
import { projects } from '@/db/schema/projects'
import { vendors } from '@/db/schema/vendors'
import { items } from '@/db/schema/items'
import { contracts, contractItems } from '@/db/schema/contract'
import { eq } from 'drizzle-orm'

// 프로젝트 목록 조회
export async function getProjects() {
  try {
    const projectList = await db.select({
      id: projects.id,
      code: projects.code,
      name: projects.name,
      type: projects.type,
    }).from(projects)
    
    return { success: true, data: projectList }
  } catch (error) {
    console.error('프로젝트 조회 오류:', error)
    return { success: false, error: '프로젝트를 조회할 수 없습니다.' }
  }
}

// 벤더 목록 조회
export async function getVendors() {
  try {
    const vendorList = await db.select({
      id: vendors.id,
      vendorName: vendors.vendorName,
      vendorCode: vendors.vendorCode,
      status: vendors.status,
    }).from(vendors)
    
    return { success: true, data: vendorList }
  } catch (error) {
    console.error('벤더 조회 오류:', error)
    return { success: false, error: '벤더를 조회할 수 없습니다.' }
  }
}

// 아이템 목록 조회 (모든 필드 포함)
export async function getItems() {
  try {
    const itemList = await db.select({
      id: items.id,
      ProjectNo: items.ProjectNo,
      itemCode: items.itemCode,
      itemName: items.itemName,
      packageCode: items.packageCode,
      smCode: items.smCode,
      description: items.description,
      parentItemCode: items.parentItemCode,
      itemLevel: items.itemLevel,
      deleteFlag: items.deleteFlag,
      unitOfMeasure: items.unitOfMeasure,
      steelType: items.steelType,
      gradeMaterial: items.gradeMaterial,
      changeDate: items.changeDate,
      baseUnitOfMeasure: items.baseUnitOfMeasure,
    }).from(items)
    
    return { success: true, data: itemList }
  } catch (error) {
    console.error('아이템 조회 오류:', error)
    return { success: false, error: '아이템을 조회할 수 없습니다.' }
  }
}

// 기존 계약 목록 조회 (프로젝트 코드, 벤더명 포함)
export async function getContracts() {
  try {
    const contractList = await db.select({
      id: contracts.id,
      contractNo: contracts.contractNo,
      contractName: contracts.contractName,
      status: contracts.status,
      projectId: contracts.projectId,
      vendorId: contracts.vendorId,
      projectCode: projects.code,
      projectName: projects.name,
      vendorName: vendors.vendorName,
      vendorCode: vendors.vendorCode,
    })
    .from(contracts)
    .leftJoin(projects, eq(contracts.projectId, projects.id))
    .leftJoin(vendors, eq(contracts.vendorId, vendors.id))
    
    return { success: true, data: contractList }
  } catch (error) {
    console.error('계약 조회 오류:', error)
    return { success: false, error: '계약을 조회할 수 없습니다.' }
  }
}

// 특정 계약의 상세 정보 조회
export async function getContractById(contractId: number) {
  try {
    const [contract] = await db.select({
      id: contracts.id,
      contractNo: contracts.contractNo,
      contractName: contracts.contractName,
      status: contracts.status,
      projectId: contracts.projectId,
      vendorId: contracts.vendorId,
      projectCode: projects.code,
      projectName: projects.name,
      vendorName: vendors.vendorName,
      vendorCode: vendors.vendorCode,
    })
    .from(contracts)
    .leftJoin(projects, eq(contracts.projectId, projects.id))
    .leftJoin(vendors, eq(contracts.vendorId, vendors.id))
    .where(eq(contracts.id, contractId))
    
    if (!contract) {
      return { success: false, error: '계약을 찾을 수 없습니다.' }
    }
    
    return { success: true, data: contract }
  } catch (error) {
    console.error('계약 상세 조회 오류:', error)
    return { success: false, error: '계약 상세 정보를 조회할 수 없습니다.' }
  }
}

// 특정 계약의 아이템들 조회
export async function getContractItems(contractId: number) {
  try {
    const contractItemList = await db.select({
      id: contractItems.id,
      contractId: contractItems.contractId,
      itemId: contractItems.itemId,
      description: contractItems.description,
      quantity: contractItems.quantity,
      unitPrice: contractItems.unitPrice,
      // 아이템 정보
      ProjectNo: items.ProjectNo,
      itemCode: items.itemCode,
      itemName: items.itemName,
      packageCode: items.packageCode,
      unitOfMeasure: items.unitOfMeasure,
    })
    .from(contractItems)
    .leftJoin(items, eq(contractItems.itemId, items.id))
    .where(eq(contractItems.contractId, contractId))
    
    return { success: true, data: contractItemList }
  } catch (error) {
    console.error('계약 아이템 조회 오류:', error)
    return { success: false, error: '계약 아이템을 조회할 수 없습니다.' }
  }
}